package qc.common.core.utils;

import org.apache.commons.lang3.StringUtils;
import qc.common.core.constants.QCConstant;

import java.util.ArrayList;
import java.util.List;

/**
 * 字符串分隔工具类
 *
 * @author QuCheng Tech
 * @since 2024/1/24
 */
public class StringSplitUtil {
    /***
     * 使用渠成公用定义的分隔符分隔字符串
     *
     * @param str 要分隔的字符串
     * @return java.lang.String[]
     * @author QuCheng Tech
     * @since 2024/1/24
     */
    public static String[] Split(String str) {
        return Split(str, false);
    }

    /***
     * 使用渠成公用定义的分隔符（中英文的逗号）分隔字符串
     *
     * @param str 要分隔的字符串
     * @param removeBlank 移除空白元素，包含空白元素、空字符串元素、去除元素前后空格
     * @return java.lang.String[]
     * @author QuCheng Tech
     * @since 2024/1/24
     */
    public static String[] Split(String str, boolean removeBlank) {
        return Split(str, QCConstant.SPLIT_STRINGS, removeBlank);
    }

    /***
     * 使用指定的分隔符分隔字符串
     *
     * @param str 要分隔的字符串
     * @param splitStr 分隔符 
     * @return java.lang.String[]
     * @author QuCheng Tech
     * @since 2024/1/24
     */
    public static String[] Split(String str, String splitStr) {
        return Split(str, splitStr, false);
    }

    /***
     * 使用指定的分隔符分隔字符串
     *
     * @param str 要分隔的字符串
     * @param splitStr 分隔符 
     * @param removeBlank 移除空白元素，包含空白元素、空字符串元素、去除元素前后空格
     * @return java.lang.String[]
     * @author QuCheng Tech
     * @since 2024/1/24
     */
    public static String[] Split(String str, String splitStr, boolean removeBlank) {
        return Split(str, new String[]{splitStr}, removeBlank);
    }

    /***
     * 使用指定的分隔符数组分隔字符串
     *
     * @param str 要分隔的字符串
     * @param splitStrs 分隔符数组
     * @return java.lang.String[]
     * @author QuCheng Tech
     * @since 2024/1/24
     */
    public static String[] Split(String str, String[] splitStrs) {
        return Split(str, splitStrs, false);
    }

    /***
     * 使用指定的分隔符数组分隔字符串
     *
     * @param str 要分隔的字符串
     * @param splitStrs 分隔符数组
     * @param removeBlank 移除空白元素，包含空白元素、空字符串元素、去除元素前后空格
     * @return java.lang.String[]
     * @author QuCheng Tech
     * @since 2024/1/24
     */
    public static String[] Split(String str, String[] splitStrs, boolean removeBlank) {
        if ((!removeBlank && StringUtils.isNotEmpty(str)) || (removeBlank && StringUtils.isNotBlank(str))) {
            //输入的字符串不能为空
            if (splitStrs != null && splitStrs.length > 0x0) {
                //对传入的分隔符数组进行逐个判断，判断非空、去重
                List<String> validSplitStrs = new ArrayList<>();
                for (String splitStr : splitStrs) {
                    if (StringUtils.isNotEmpty(splitStr)) {
                        if (!validSplitStrs.contains(splitStr)) {
                            validSplitStrs.add(splitStr);
                        }
                    }
                }
                //判断有效的分隔符是否为空，不为空时进行分隔处理
                int validSplitStrCount = validSplitStrs.size();
                if (validSplitStrCount > 0x1) {
                    //有多重分隔符，使用正则表达式匹配其中任意1种分隔符
                    //正则：使用竖线|分隔前后2个分隔符，使用加号+表示一个或多个
                    StringBuilder sbRegex = new StringBuilder();
                    for (int i = 0; i < validSplitStrCount; i++) {
                        sbRegex.append(validSplitStrs.get(i));

                        if (i + 1 == validSplitStrCount) {
                            //最后1个分隔符不需要添加竖线，添加加号+表示匹配其中1个或多个
                            sbRegex.append("+");
                        } else {
                            sbRegex.append("|");
                        }
                    }

                    String[] strs = str.split(sbRegex.toString());
                    if (removeBlank) {
                        //如果要移除空白，移除空白元素、移除空白字符串元素、去除每个元素的前后空白
                        List<String> result = new ArrayList<>();

                        for (String el : strs) {
                            if (StringUtils.isNotBlank(el))
                                result.add(el.trim());
                        }

                        if (result.size() > 0x0)
                            return result.stream().toArray(String[]::new);
                    } else {
                        return strs;
                    }
                } else if (validSplitStrCount == 0x1) {
                    //只有1种分隔符时，直接使用split方法
                    String[] strs = str.split(validSplitStrs.get(0x0));
                    if (removeBlank) {
                        //如果要移除空白，移除空白元素、移除空白字符串元素、去除每个元素的前后空白
                        List<String> result = new ArrayList<>();

                        for (String el : strs) {
                            if (StringUtils.isNotBlank(el))
                                result.add(el.trim());
                        }

                        if (result.size() > 0x0) {
                            //使用stream中方法报错StackOverflowError
                            return result.stream().toArray(String[]::new);
                            //String[] resultArray = new String[result.size()];
                            //
                            //for (int i = 0; i < result.size(); i++) {
                            //    resultArray[i] = result.get(i);
                            //}
                            //
                            //return resultArray;
                        }

                    } else {
                        return strs;
                    }
                }
            }

            //如果输入的字符串不为空（可能为空格等），如果分隔符为空，返回输入的字符串
            if (removeBlank) {
                if (StringUtils.isNotBlank(str))
                    return new String[]{str.trim()};
            } else {
                return new String[]{str};
            }
        }

        //默认返回null
        return null;
    }

    /***
     * 将字符串集合拼接为一个字符串
     *
     * @param strs 字符串集合 
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2025/1/15
     */
    public static String Join(List<String> strs) {
        return Join(strs, QCConstant.SPLIT_STRING);
    }

    /***
     * 将字符串集合拼接为一个字符串
     *
     * @param strs 字符串集合 
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2025/1/15
     */
    public static String Join(String[] strs) {
        return Join(strs, QCConstant.SPLIT_STRING);
    }

    /***
     * 将字符串集合拼接为一个字符串
     *
     * @param strs 字符串集合 
     * @param splitString 拼接使用的分隔符 
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2025/1/15
     */
    public static String Join(List<String> strs, String splitString) {
        if (strs != null && strs.size() > 0x0 && StringUtils.isNotBlank(splitString)) {
            //return Join(Arrays.stream(strs).boxed().toArray(Integer[]::new), splitString);
            return Join(strs.stream().toArray(String[]::new), splitString);
        }

        return null;
    }

    /***
     * 将字符串集合拼接为一个字符串
     *
     * @param strs 字符串集合 
     * @param splitString 拼接使用的分隔符 
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2025/1/15
     */
    public static String Join(String[] strs, String splitString) {
        if (strs != null && strs.length > 0x0 && StringUtils.isNotBlank(splitString)) {
            StringBuilder sb = new StringBuilder();
            for (String s : strs) {
                sb.append(s + splitString);
            }
            //移除最后一个分隔符，返回中长度减去分隔符的长度
            String result = sb.toString();
            return result.substring(0x0, result.length() - splitString.length());
        }

        return null;
    }
}
